/*
2021/10/19
主要目标是vector类的实现
依旧没有安装成功doxygen
所以还是手写注释
主要代码copy自课本
*/

#ifdef _VECTOR_H
#dedine _VECTOR_H

#include<iostream>
#include<algorithm>
//引入必要库

template<typename Object>
class Vector
{
 public:
  explicit Vector (int initSize = 0) : theSize { initSize },
   theCapacity{ initSize + SPARE_CAPACITY}
   {objects = new Object [theCapacity];}
   //build theCapacity,initialize it and allocate sapce for it
   // user can decide which size to use or the default one
   
 Vector(const Vector & rhs ):theSize{rhs.theSize},
     theCapacity{rhs.theCapacity},objects{nullptr}
     //used to build a copy
     {
       objects = new Object [ theCapacity ];
       for(int k = 0;k<theSize;++k)
	 objects[k] = rhs.objects[k];
     }

     Vector & operator= ( const Vector & rhs)
       //can be used to swap
       {
	Vector copy = rhs;
	std::swap(*this ,copy);
	///没记错的话swap交换的是地址来着？
	return *this;
       }

     ~Vector ()
       //内存管理用 析构函数 英文不好 尝试写两行英语注释表示不出来了（好吧其实是懒得换输入法）
       {delete [] objects}
     
     Vector( Vector && rhs): theSize{rhs.theSize},
       theCapacity{ rhs.theCapacity },objects{rhs.objects}
       //initialize the function
       {
	rhs.objects = nullptr;
	rhs.theSize = 0;
	rhs.theCapacity = 0;
       }

     Vector & operator= ( Vector && rhs)
	 {
	  std::swap(theSize,rhs.theSize);
	  std::swap(theCapacity,rhs.theCapacity);
	  std::swap(objects,rhs.objects);

	  return *this;
	 }


     
     void resize (int newSize)
     {
      if (newSize > theCapacity)
	reverse( newSize*2 );
      theSize = newSize;
     }
     //define the resize ,分配给更大空间，两倍来着
     
     void reverse (int newCapacity)
     //分配一个不小于原有空间的新空间
     {
      if (newCapacity < theSize)
	return;
      Object *newArray = new Object[ newCapacity ];
      for (int k=0; k< theSize;++k)
	newArray[ k ] = std::move(objects[ k ]);
      theCapacity = newCapacity;
      std::swap(objects, newArray);
      delete [] newArray;
      //记得擦屁股？（笑）
     }
  //某个运算符，是用来返回某位置元素用的
  Object & operator[]( int index)
  {return objects[index];}
  const Object & operator[](int index) const
  {
    return objects[index];
  }

  bool empty()const
  //判断空向量用的
  {
    return size() ==0;
    //这么简短的写法好漂亮，我根本不会这么写...果然你不能对一个没上过C程的人要求太高
  }

  int size() const
  //返回theSize值
  {
    return theSize;
  }

  int capacity() const
  //返回空间值
  {
    return theCapacity;
  }

  void push_back(const Object& x)
  //按照3.3中的翻译似乎是把x添加到尾巴上？的确我还得适应一下英文课本的阅读
  //补充 似乎还有自动扩大空间的作用
  {
    if（theSize == theCapacity）
      reverse(2*theCapacity+1);
    objects[theSize++] = x;
  }

  void push_back(const Object&& x)
  {
    if (theSize == theCapacity)
      reverse(2*theCapacity + 1);
    objects[theSize++] = std::move(x);
  }
  //上面那个是针对不同类型内容的一次重载


  void pop_back()
  //删除尾巴上的的对象
  {
    --theSize;
    //似乎不用真的删除？而是把标签退一格假装不存在？
  }

  const Object& back() const
  //返回表的尾端的对象，准确来说是倒数第二个位置似乎？取决于你对尾的理解
  {
    return objects[theSize - 1];
  }

  typedef Object* iterator;
  typedef Object* const_iterator;
  //定义一个迭代器，是这么叫来着？
  //或者叫重命名？查到typedef的意思是为复杂声明定义简单的别名

  iterator begin()
  //返回第一个元素位置
  {
    return &objects[0];
  }

  const_iterator begin() const
  {
    return &objects[0];
  }

  iterator end()
  //返回尾端，似乎是打个标记的意思
  {
    return &objects[size()];
  }

  const_iterator end() const
  {
    return &object[size()];
  }

  static SPARE_CAPACITY = 16;

private:
  int theSize;
  int theCapacity;
  Object* objects;
     //课本上内容到此为止

     
}

#else
//DO NOTHING
#endif
